<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

</body>
<script>
    // 构造函数Array新增的方法 (类似Array.isArray())

    // Array.from()  将两类对象转为真正的数组 (1. 伪数组 2. ES6新增 Set Map结构)

    // Array.of()  方法用于将一组值，转换为数组。

    // console.log(Array.of(1, 4, 7)); // [1,4,7]
    // console.log(Array.of(10)); // [10]
    // console.log(Array.of("10"));// ["10"]

    // 解决: new Array() 创建数组的问题
    // console.log(new Array(1, 4, 7));
    // console.log(new Array(10)); // [,,,,,,,,,]
    // console.log(new Array("10")); // ["10"]





    // 数组的新增方法

    // 数组的遍历 
    // find(function(item,index,array){})    遍历数组 每次循环时 执行传入的函数,回调函数设置一个条件 => 返回满足条件的第一个元素  (存在 => 元素 不存在 => undefined)
    // findIndex(function(item,index,array){}) 遍历数组 每次循环时 执行传入的函数,回调函数设置一个条件 => 返回满足条件的第一个元素的下标  (存在 => 下标 不存在 => -1)

    // findLast(function(item,index,array){})    遍历数组 每次循环时 执行传入的函数,回调函数设置一个条件 => 返回满足条件的最后一个元素  (存在 => 元素 不存在 => undefined)
    // findLastIndex(function(item,index,array){}) 遍历数组 每次循环时 执行传入的函数,回调函数设置一个条件 => 返回满足条件的最后一个元素的下标  (存在 => 下标 不存在 => -1)

    var list = [1, 4, 7, 2, 5, 8, 3, 6, 9];

    // var result = list.filter(function (item) {
    //     return item % 2 == 0;
    // });
    // console.log(result); // 所有满足条件的
    // console.log(result[0]); // 第一个满足

    // var result = list.find(function (item) {
    //     return item % 2 == 0;
    // });
    // console.log(result);

    // var result = list.findIndex(function (item) {
    //     return item % 2 == 0;
    // });
    // console.log(result);

    // var result = list.findLast(function (item) {
    //     return item % 2 == 0;
    // });
    // console.log(result);

    // var result = list.findLastIndex(function (item) {
    //     return item % 2 == 0;
    // });
    // console.log(result);


    // fill() 方法使用给定值，填充一个数组。
    // 返回值: 被修改后的原数组
    // 是否影响原数组:影响

    // 创建长度为10的数组, 数组中每个元素都为false
    // var arr = new Array(10).fill(false);
    // console.log(arr);

    // var list = [1, 4, 7, 2, 5, 8, 3, 6, 9, 10];
    // var result = list.fill(0);
    // console.log("返回值", result);
    // console.log("原数组", list);


    // includes()  表示某个数组是否包含给定的值 (存在=> true 不存在返回false)
    // var list = [1, 4, 7, 2, 5, 8, NaN, 3, 6, 9, 10];

    // console.log(list.indexOf(NaN));  // -1 indexOf() 无法判断数组中是否存在NaN
    // console.log(list.includes(NaN));    // true includes() 可以判断数组中是否存在NaN


    //(数组扁平化处理)  => 将多维数组 拉平为一维数组



    /*
        var list = [];
        for (var i = 0; i < arr.length; i++) {
            var item = arr[i]; // 1, 4, 7, [2, 4, 5]
            if (Array.isArray(item)) {
                // 重复第一套操作 item [2, 4, 5]
                for (var j = 0; j < item.length; j++) {
                    var t1 = item[j];
                    if (Array.isArray(t1)) {
                        // 重复第一套操作

                    } else {
                        list.push(t1);
                    }

                }


            } else {
                list.push(item);
            }
        }
    */

    /* function deepCopy(arr) {
        var list = [];
        for (var i = 0; i < arr.length; i++) {
            var item = arr[i]; // 1, 4, 7, [2, 4, 5]
            if (Array.isArray(item)) { // [2,4,5]
                var newArr = deepCopy(item); // 返回新数组
                list.push(newArr);
            } else {
                list.push(item);
            }
        }
        return list;
    } */

    /*    function myFlat(arr) { // [1, 4, 7, [2, 4, 5]]   [2,4,5]
           var list = [];
           for (var i = 0; i < arr.length; i++) {
               var item = arr[i]; // 1, 4, 7, [2, 4, 5]
               if (Array.isArray(item)) { // [2,4,5]
                   var newArr = myFlat(item); // 返回新数组
                   list = list.concat(newArr);
               } else {
                   list.push(item);
               }
           }
           return list;
       }
   
       var arr = [1, 4, 7, [2, 4, 5, [3, 6, 9]]];
   
       console.log(myFlat(arr));
    */

    /*  
        var arr = [1, 4, 7, [2, 4, 5, [3, 6, 9]]];
        console.log(arr.toString().split(",")); 
    */

    // flat()  数组拉平
    // 返回值: 新数组
    // 是否影响原数组: 不影响

    // 注意: flat()默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想要拉平的层数，默认为1。
    // 如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。

    // var list = [1, 4, 7, [2, 4, 5]];
    // var result = list.flat();
    // console.log("返回值", result);
    // console.log("原数组", list);

    // var list = [1, 4, 7, [2, 4, 5, [3, 6, 9]]];
    // // var result = list.flat();
    // var result = list.flat(2);
    // console.log("返回值", result);
    // console.log("原数组", list);

    // var list = [1, 4, 7, [2, 4, [2, 8, 5, [5, 7, 9, [6, 7, 2, [5, 9, 1, [3, 7, 2, [4, 5, 6]]]]]], 5, [3, 6, 9]]];
    // var result = list.flat(Infinity);
    // console.log("返回值", result);
    // console.log("原数组", list);



    // flatMap()  是map和flat的组合版 -> 先map,再flat

    var list = [1, 4, 7, 2, 5, 8, 3, 6, 9];

    // 将原数组中的每个元素 扩大两倍 在放到新数组中(原本的 + 扩大的)

    // var newArr = list.map(function (item) {
    //     return [item, item * 2];
    // })
    // console.log(newArr);

    // var result = newArr.flat();
    // console.log(result);

    var result = list.flatMap(function (item) {
        return [item, item * 2];
    })
    console.log(result);















</script>

</html>